#include "musicwindow.h"
#include "ui_musicwindow.h"


MusicWindow::MusicWindow(QWidget *parent)
    : QMainWindow(parent)
    , ui(new Ui::MusicWindow)
{
    ui->setupUi(this);
    lyricsWindow = new LyricsWindow(ui->widget_main);//初始化歌词窗体
    lyricsWindow->hide();//默认隐藏歌词窗体
    is_showLyric=false;//默认不显示歌词
    currentMode=0;//初始化播放模式为顺序播放
    isPlayMV=false;
    this->setWindowIcon(QIcon(":/img/logo.svg"));//设置窗体图标
    ui->horizontalSlider_volume->setRange(0,100);//设置音量范围为0-100
    ui->horizontalSlider_volume->setValue(90);//初始音量为90
    clearAll();
    // 加载样式表
    QFile file(":/style.css");
    if (file.open(QIODevice::ReadOnly))
    {
        this->setStyleSheet(QString(file.readAll()));
        file.close();
    }
    //初始化数据库
    recently_played=new my_database("recently_played.db");
    query=QSqlQuery("recently_played.db");

    //创建一个网络访问管理对象
    manager = new QNetworkAccessManager(this);//歌曲信息
    imgUrl_manager=new QNetworkAccessManager(this);//歌单图片
    //绑定歌曲搜索信息、歌单图片网络请求信号
    connect(manager, SIGNAL(finished(QNetworkReply*)),this, SLOT(replyFinished(QNetworkReply*)));
    connect(imgUrl_manager, SIGNAL(finished(QNetworkReply*)),this, SLOT(replyFinished2(QNetworkReply*)));


    //初始化一个标准10行4列的模型数据表
    //初始化一个标准10行列的模型数据表
    pModel = new QStandardItemModel(10,4,ui->tableView_songs);
    //设置表头
    QStringList head=QStringList()<<"歌曲"<<"歌手"<<"专辑"<<"时长";
    pModel->setHorizontalHeaderLabels(head);
    // 设置水平标头的文本靠左对齐
    ui->tableView_songs->horizontalHeader()->setDefaultAlignment(Qt::AlignLeft);

    //音乐播放
    playlist = new QMediaPlaylist;//媒体播放列表
    player = new QMediaPlayer;//媒体播放器
    player->setPlaylist(playlist);//把播放列表设置给播放器

    //音乐时长变化信号绑定
    connect(player,SIGNAL(positionChanged(qint64)),this,SLOT(positionChanged_slot(qint64)));
    //切换歌曲时长变化信号和槽绑定
    connect(player,SIGNAL(durationChanged(qint64)),this,SLOT(durationChanged_slot(qint64)));
    //歌词显示信号绑定
    connect(ui->label_albumPic, SIGNAL(show_lyrics()), this, SLOT(on_label_albumPic_linkActivated()));

}

MusicWindow::~MusicWindow()
{
    delete ui;
}


//格式化时间
QString MusicWindow::format_time(int milliseconds) {
    // 将毫秒转换为秒
    int seconds = milliseconds / 1000;

    // 计算分钟和秒
    int minutes = seconds / 60;
    int remainingSeconds = seconds % 60;

    // 使用 QTime 格式化时间，只有分钟和秒
    QTime time(0, minutes, remainingSeconds);
    return time.toString("mm:ss");  // 返回格式化的字符串 "mm:ss"
}

/*窗体移动 也就是计算窗体左上角位置的差值*/
void MusicWindow::mousePressEvent(QMouseEvent *event)
{
    // 检查鼠标按钮是否为左键
    if(event->button() == Qt::LeftButton)
    {
        // 设置鼠标按下标志为真
        mousePress = true;
    }
    // 计算窗口移动的距离，获取鼠标在全局坐标系中的位置与窗口当前位置的差值
    movePoint = event->globalPos() - pos();
}
void MusicWindow::mouseReleaseEvent(QMouseEvent *event)
{
    // 不使用event参数，避免编译器警告
    Q_UNUSED(event)
    // 设置鼠标按下标志为假，表示鼠标已释放
    mousePress = false;
}
void MusicWindow::mouseMoveEvent(QMouseEvent *event)
{
    // 如果鼠标按下标志为真，表示正在拖动窗口
    if(mousePress)
    {
        // 获取当前鼠标在全局坐标系中的位置
        QPoint movePos = event->globalPos();
        // 移动窗口到新的位置，新的位置为当前鼠标位置减去移动距离
        move(movePos - movePoint);
    }
}

//喜欢/取消喜欢
void MusicWindow::on_pushButton_like_clicked(bool checked)
{
    //喜欢
    if(checked)
    {
        ui->pushButton_like->setIcon(QIcon(":/img/Like.svg"));
        ui->pushButton_like->setToolTip("取消喜欢");
        isLike_list[current_index]=1;
        saveMusic("myFavorite",current_index); // 保存到我的收藏列表中
    }
    //取消喜欢
    else
    {
        ui->pushButton_like->setIcon(QIcon(":/img/dislike.svg"));
        ui->pushButton_like->setToolTip("喜欢");
        isLike_list[current_index]=0;
        //从我的收藏列表中删除
        sql = QString("DELETE FROM myFavorite where id=%1;").arg(song_id);
        recently_played->excutSql(query, sql); // 执行sql语句
    }
}

//播放与暂定
void MusicWindow::on_pushButton_switch_clicked(bool checked)
{
    //播放
    if(checked)
    {
        ui->pushButton_switch->setIcon(QIcon(":/img/PauseCircle.svg"));
        ui->pushButton_switch->setToolTip("暂停");
        //判断是否播放MV
        if(isPlayMV)
        {
            mvPlayer->play();
        }
        else
        {
            player->play();
        }
    }
    //暂停
    else
    {
        ui->pushButton_switch->setIcon(QIcon(":/img/PlayCircle.svg"));
        ui->pushButton_switch->setToolTip("播放");
        //判断是否播放MV
        if(isPlayMV)
        {
            mvPlayer->pasue();
        }
        else
        {
            player->pause();
        }
    }
}

//静音与取消静音
void MusicWindow::on_pushButton_volume_clicked(bool checked)
{
    //静音
    if(checked)
    {
        player->setVolume(0);
        ui->pushButton_volume->setIcon(QIcon(":/img/noVolume.svg"));
        ui->pushButton_volume->setToolTip("取消静音");
    }
    //取消静音
    else
    {
        player->setVolume(ui->horizontalSlider_volume->value());
        ui->pushButton_volume->setIcon(QIcon(":/img/volume.svg"));
        ui->pushButton_volume->setToolTip("静音");
    }
}

//顺序播放索引
void MusicWindow::sequeIndex()
{
    index_list.clear();
    for (int i = 0; i < songsId_list.size(); ++i)
    {
        index_list.append(i); // 默认顺序
    }
}

//随机播放索引
void MusicWindow::randomIndex()
{
    std::random_shuffle(index_list.begin(), index_list.end());
}

//更新当前索引
void MusicWindow::updateIndex()
{
    current_index = index_list[current_index];
}

//加载本地资源
void MusicWindow::loadLocalFile()
{
    QStringList filters;
    filters << tr("音乐文件 (*.mp3 *.wav *.flac)")
            << tr("视频文件 (*.mp4 *.avi *.mkv)")
            << tr("所有文件 (*)");

    QString fileName = QFileDialog::getOpenFileName(this, tr("打开文件"), "", filters.join(";;"));
    if (!fileName.isEmpty()) {
        if (fileName.endsWith(".mp3") || fileName.endsWith(".wav") || fileName.endsWith(".flac")) {
            player->setMedia(QUrl::fromLocalFile(fileName));
            player->play(); // 播放音乐
            ui->pushButton_switch->setIcon(QIcon(":/img/PauseCircle.svg"));
            ui->pushButton_switch->setToolTip("暂停");
        } else if (fileName.endsWith(".mp4") || fileName.endsWith(".avi") || fileName.endsWith(".mkv")) {
            player->setMedia(QUrl::fromLocalFile(fileName));
            // 创建视频输出窗口
            QVideoWidget *videoWidget = new QVideoWidget;
            videoWidget->setFullScreen(true);
            player->setVideoOutput(videoWidget);
            player->play(); // 播放视频
        }
    }
}

//最近播放列表
void MusicWindow::set_playlist(QString listName)
{
    //从数据库中导入最近播放数据到模型
    QSqlTableModel *model = new QSqlTableModel;
    model->setTable(listName); // 设置要查询的表
    model->select(); // 使用recently表中的数据填充模型
    // 设置模型的每列数据
    model->setHeaderData(0, Qt::Horizontal, QObject::tr("id"));
    model->setHeaderData(1, Qt::Horizontal, QObject::tr("mvid"));
    model->setHeaderData(2, Qt::Horizontal, QObject::tr("songName"));
    model->setHeaderData(3, Qt::Horizontal, QObject::tr("albumName"));
    model->setHeaderData(4, Qt::Horizontal, QObject::tr("singerName"));
    model->setHeaderData(5, Qt::Horizontal, QObject::tr("duration"));
    model->setHeaderData(6, Qt::Horizontal, QObject::tr("imgUrl"));
    model->setHeaderData(7, Qt::Horizontal, QObject::tr("isLike"));
    // 将模型设置给QTableView
    ui->tableView_songs->setModel(model);
    ui->tableView_songs->hideColumn(0);
    ui->tableView_songs->hideColumn(1);
    ui->tableView_songs->hideColumn(6);
    ui->tableView_songs->hideColumn(7);
    //清空歌曲信息表
    clearAll();
    playlist->clear();//清空播放列表
    // 遍历模型的每一行，设置模型的每列数据并填充列表
    for (int row = 0; row < model->rowCount(); ++row)
    {
        song_id=model->data(model->index(row, 0)).toInt();
        songsId_list.push_back(model->data(model->index(row, 0)).toInt());
        mvID_list.push_back(model->data(model->index(row, 1)).toInt());
        songName_list.push_back(model->data(model->index(row, 2)).toString());
        albumName_list.push_back(model->data(model->index(row, 3)).toString());
        singer_list.push_back(model->data(model->index(row, 4)).toString());
        duration_list.push_back(model->data(model->index(row, 5)).toString());
        imgUrl_list.push_back(model->data(model->index(row, 6)).toString());
        isLike_list.push_back(model->data(model->index(row, 7)).toInt());
        //添加音乐的播放连接到播放列表，这里使用的是网易云音乐的地址
        playlist->addMedia(QUrl(QString("http://music.163.com/song/media/outer/url?id=%1.mp3").arg(song_id)));
    }
}

//清空歌曲信息表
void MusicWindow::clearAll()
{
    songsId_list.clear();//歌曲ID列表
    duration_list.clear();//歌曲时长链表
    imgUrl_list.clear();//专辑图片链表
    songName_list.clear();//歌名
    singer_list.clear();//歌手
    albumName_list.clear();//专辑名列表
    mvID_list.clear();//MVID列表
    index_list.clear();//索引表
    isLike_list.clear();//是否收藏
}

//保存音乐信息到数据库
void MusicWindow::saveMusic(const QString &tableName,int index)
{
    // 存储当前播放歌曲相关信息
    query.prepare(QString("SELECT COUNT(*) FROM %1 WHERE id = :song_id").arg(tableName));
    query.bindValue(":song_id", song_id);
    query.exec();
    query.next();

    // 判断当前歌曲ID号是否已经存在
    if (query.value(0).toInt() == 0)
    {
        // 如果不存在，执行插入操作
        QString sql = QString("INSERT INTO %1 VALUES ('%2','%3','%4','%5','%6','%7','%8','%9');")
                .arg(tableName) // 使用传入的表名
                .arg(song_id).arg(mvid).arg(songName_list[index]).arg(albumName_list[index])
                .arg(singer_list[index]).arg(duration_list[index]).arg(imgUrl_list[index].arg(isLike_list[index]));
        recently_played->excutSql(query, sql); // 执行sql语句
    }
}
//顺序、随机、单曲循环播放
void MusicWindow::on_pushButton_mode_clicked()
{
    switch (currentMode%3)
    {
    //顺序
    case 0:
        ui->pushButton_mode->setIcon(QIcon(":/img/repeat.svg"));
        sequeIndex();
        //        playlist->setPlaybackMode(QMediaPlaylist::Sequential); // 设置顺序播放
        ui->pushButton_mode->setToolTip("随机播放");
        break;
        //随机
    case 1:
        ui->pushButton_mode->setIcon(QIcon(":/img/random.svg"));
        randomIndex();
        //        playlist->setPlaybackMode(QMediaPlaylist::Random); // 设置随机播放
        ui->pushButton_mode->setToolTip("单曲循环");
        break;
        //单曲循环
    case 2:
        ui->pushButton_mode->setIcon(QIcon(":/img/repeat-one-line.svg"));
        //        playlist->setPlaybackMode(QMediaPlaylist::CurrentItemInLoop); // 设置单曲循环
        ui->pushButton_mode->setToolTip("顺序播放");
        break;
    }
    currentMode++;
    updateIndex();//更新当前索引
}

//关闭窗口
void MusicWindow::on_pushButton_close_clicked()
{
    this->close();
}

//最小化窗口
void MusicWindow::on_pushButton_minsize_clicked()
{
    this->showMinimized();
}

//最大化窗口、还原
void MusicWindow::on_pushButton_maxsize_clicked(bool checked)
{
    if(checked)
    {
        ui->pushButton_maxsize->setIcon(QIcon(":/img/Max2normal.svg"));
        this->showMaximized();
    }
    else
    {
        ui->pushButton_maxsize->setIcon(QIcon(":/img/max.svg"));
        this->showNormal();
    }
}

//歌曲搜索信息请求槽
void MusicWindow::replyFinished(QNetworkReply*reply)
{
    //判断网页是否响应成功
    //    QNetworkRequest::HttpStatusCodeAttribute网址返回的状态码
    if(200==reply->attribute(QNetworkRequest::HttpStatusCodeAttribute))
    {
        parseJson_search(reply->readAll());//解析json数据
//        qDebug()<<QString(reply->readAll())<<endl;//将字节数组转换成字符串
    }
    else
    {
        QMessageBox::warning(this,"网页访问失败","请求超时!");
    }

}

//歌单封面请求槽
void MusicWindow::replyFinished2(QNetworkReply*reply)
{
    //判断网页是否响应成功
    //    QNetworkRequest::HttpStatusCodeAttribute网址返回的状态码
    if(200==reply->attribute(QNetworkRequest::HttpStatusCodeAttribute))
    {
        parseJson_coverImg(reply->readAll());//解析json数据
//        qDebug()<<QString(reply->readAll())<<endl;//将字节数组转换成字符串
    }
    else
    {
        QMessageBox::warning(this,"网页访问失败","请求超时!");
    }

}

//JSON歌曲详细信息解析,用于获取歌曲歌单封面图片
void MusicWindow::parseJson_coverImg(QByteArray byteArray)
{
    QString imgUrl;
    QJsonDocument doc = QJsonDocument::fromJson(byteArray);//直接从字节数组中获得一个JSON文档
    if(doc.isObject())//问文档内部是否是一个对象？
    {
        QJsonObject obj = doc.object();//返回文档内的对象
        if(obj.contains("songs") == false)//问文档对象是否包含songs关键字
        {
            qDebug()<<"错误的JSON对象"<<endl;
            return;
        }
        QJsonValue var = obj.value("songs");//获得关键字songs对应的结果
        if(var.isArray() == false)
        {
            qDebug()<<"songs的值不是一个数组"<<endl;
            return;
        }
        QJsonArray songArr = var.toArray();//把songs的值转为一个数组
        if(songArr[0].isObject())//判断该数组中是否是一个对象
        {
            QJsonObject songsObj=songArr[0].toObject();
            if(songsObj.contains("album"))
            {
                var=songsObj.value("album");
                QJsonObject albumObj=var.toObject();
                if(albumObj.contains("blurPicUrl"))
                {
                    var=albumObj.value("blurPicUrl");
                    imgUrl=var.toString();
//                    qDebug()<<imgUrl;
                    imgUrl_list.push_back(imgUrl);
                }
            }
        }
    }
}


//JSON搜索数据解析 用来读取和写入JSON字符串，也可以把JSON字符串转为JSON对象
void MusicWindow::parseJson_search(QByteArray byteArray)
{
    unsigned int id=0;
    int mvid=-1;
    QString songName;
    QString albumName;
    QString singerName;
    QString duration;


    QJsonDocument doc = QJsonDocument::fromJson(byteArray);//直接从字节数组中获得一个JSON文档
    if(doc.isObject())//问文档内部是否是一个对象？
    {
        QJsonObject obj1 = doc.object();//返回文档内的对象
        if(obj1.contains("result") == false)//问文档对象是否包含result关键字
        {
            qDebug()<<"错误的JSON对象"<<endl;
            return;
        }
        QJsonValue var = obj1.value("result");//获得关键字result对应的结果
        if(var.isObject() == false)
        {
            qDebug()<<"result的值不是一个对象"<<endl;
            return;
        }
        QJsonObject resultObj = var.toObject();//把result的值转为一个对象
        if(resultObj.contains("songs") == false)
        {
            qDebug()<<"JSON对象没有歌曲"<<endl;
            return;
        }
        var = resultObj.value("songs");//得到关键字songs的值
        if(var.isArray())//是否为数组？
        {
            QJsonArray songsArr = var.toArray();//把songs的值转为一个数组
//            qDebug()<<"一共搜索到"<<songsArr.size()<<"首歌曲"<<endl;
            for(int i = 0 ; i < songsArr.size() ; i++)
            {
                QJsonObject songObj = songsArr[i].toObject();//把下标为i的元素转为对象
                if(songObj.contains("id"))
                {
                    QJsonValue varID = songObj.value("id");//获取关键字为id的元素的值
                    id = varID.toDouble();//把值转为整数
                    songsId_list.push_back(id);//将歌曲ID存入到链表中
                }
                if(songObj.contains("mvid"))
                {
                    QJsonValue varmvID = songObj.value("mvid");//获取关键字为mvid的元素的值
                    mvid = varmvID.toInt();//把值转为无符号整数
                    mvID_list.push_back(mvid);//将MVID存入到链表中
//                    qDebug()<<mvid;
                }
                if(songObj.contains("name"))
                {
                    QJsonValue varName = songObj.value("name");
                    songName = varName.toString();
                    songName_list.push_back(songName);
                }
                if(songObj.contains("album"))//是否包含专辑
                {
                    QJsonValue varAlbum = songObj.value("album");//得到专辑关键字的值
                    if(varAlbum.isObject())
                    {
                        QJsonObject albumObj = varAlbum.toObject();//把专辑的值转为对象
                        if(albumObj.contains("name"))
                        {
                            QJsonValue varAlbumName =  albumObj.value("name");
                            albumName = varAlbumName.toString();//得到专辑名
                            albumName_list.push_back(albumName);
                        }

                    }
                }
                if(songObj.contains("artists"))//是否包含作者关键字
                {
                    QJsonValue varArtists = songObj.value("artists");
                    if(varArtists.isArray())//作者的值是否为数组？
                    {
                       QJsonArray arrArtists = varArtists.toArray();
                       for (int i = 0; i < arrArtists.size(); ++i) {//遍历作者数组
                           if(arrArtists[i].isObject())
                           {
                               QJsonObject artistsObj = arrArtists[i].toObject();
                               if(artistsObj.contains("name"))
                               {
                                   QJsonValue varArtistsName = artistsObj.value("name");
                                   singerName+= varArtistsName.toString();//把名字加入到字符串中
                                   singer_list.push_back(singerName);
//                                   singerName+=" ";//中间留一个空格
                               }
                           }
                       }
                    }
                }
                if(songObj.contains("duration"))
                {
                    QJsonValue varDuration = songObj.value("duration");//获取关键字为duration的元素的值
                    unsigned int time = varDuration.toDouble();//把值转为整数
                    duration=MusicWindow::format_time(time);//格式化时间
                    duration_list.push_back(duration);//保存当前搜索歌曲每首歌的时长
                }
                isLike_list.push_back(0);//默认添加歌曲为不喜欢
                //添加音乐的播放连接到播放列表，这里使用的是网易云音乐的地址
                playlist->addMedia(QUrl(QString("http://music.163.com/song/media/outer/url?id=%1.mp3").arg(id)));
                // 加载专辑图片
                imgUrl_manager->get(QNetworkRequest(QUrl(QString("https://music.163.com/api/song/detail?ids=[%1]").arg(id))));
                //显示当前搜索信息
                QStandardItem *item = new QStandardItem(songName);//歌名
                pModel->setItem(i, 0, item);
                item = new QStandardItem(singerName);//歌手
                pModel->setItem(i, 1, item);
                item = new QStandardItem(albumName);//专辑
                pModel->setItem(i, 2, item);
                item = new QStandardItem(duration);//时长
                pModel->setItem(i, 3, item);
                ui->tableView_songs->setModel(pModel);//设置模型
                singerName.clear();//清空歌手名
            }
        }
    }
}

//音乐搜索点击槽
void MusicWindow::on_pushButton_search_clicked()
{
    //每次搜索的时候清空上一次搜索保存的信息
    clearAll();
    playlist->clear();//清空播放列表
    // 查询数据
    QString search_info = ui->lineEdit_search->text().trimmed();//使用trimmed去掉空格
    manager->get(QNetworkRequest(QUrl(QString("http://music.163.com/api/search/get/web?csrf_token=hlpretag=&hlposttag=&s=%1&type=1&offset=0&total=true&limit=20").arg(search_info))));
}

//时长变化槽
void MusicWindow::positionChanged_slot(qint64 position)
{
    ui->horizontalSlider_musicProgress->setValue(position);  //更新进度条
    current_time=ui->horizontalSlider_musicProgress->value();//更新播放时长
    ui->label_currenttime->setText(MusicWindow::format_time(current_time));//显示到标签上
}

//切换歌曲时长变化槽
void MusicWindow::durationChanged_slot(qint64 duration)
{
    ui->horizontalSlider_musicProgress->setRange(0,duration);//将进度条范围设置为音乐时长
}

//滑动滑条控制歌曲进度
void MusicWindow::on_horizontalSlider_musicProgress_sliderReleased()
{
    qint64 var = ui->horizontalSlider_musicProgress->value();//得到滑块当前值
    player->setPosition(var);//得到滑块当前值做为音乐播放的当前时间
    current_time=ui->horizontalSlider_musicProgress->value();//更新播放时长
    ui->label_currenttime->setText(MusicWindow::format_time(current_time));//显示到标签上
    //判断滑块是否到达终点
    connect(ui->horizontalSlider_musicProgress, &QSlider::valueChanged, this, [=](){
        if(ui->horizontalSlider_musicProgress->value()==ui->horizontalSlider_musicProgress->maximum())
        {
            //默认为顺序播放
            if(ui->pushButton_mode->isChecked())
            {
                current_index++;
            }
            play_music(current_index); // 播放当前索引歌曲
        }
    });
}

//音乐播放
void MusicWindow::play_music(int index)
{
//    qDebug()<<"播放index="<<index;
    //判断是否是我的收藏歌曲
    if(isLike_list[current_index])
    {
        ui->pushButton_like->setIcon(QIcon(":/img/Like.svg"));
        ui->pushButton_like->setToolTip("取消喜欢");
    }
    else
    {
        ui->pushButton_like->setIcon(QIcon(":/img/dislike.svg"));
        ui->pushButton_like->setToolTip("喜欢");
    }
    lyricsWindow->set_songId(song_id);//获取当前歌曲歌词信息
    //播放按钮启动
    ui->pushButton_switch->setIcon(QIcon(":/img/PauseCircle.svg"));
    ui->pushButton_switch->setToolTip("暂停");
    ui->label_duration->setText(duration_list[index]);//显示当前歌曲时长
    ui->label_songname->setText(songName_list[index]);//显示歌名
    ui->label_author->setText(singer_list[index]);//显示歌手
    //设置播放列表播放第几首歌
    playlist->setCurrentIndex(index);
    player->play();//播放歌曲
    QNetworkAccessManager *img_manager = new QNetworkAccessManager(this);
    QUrl imageUrl(imgUrl_list[index]);
    QNetworkRequest request(imageUrl);
    QNetworkReply *reply=img_manager->get(request);//发起请求
    //绑定专辑图片加载信号
    connect(reply, &QNetworkReply::finished, this, [=]() {
        if (reply->error() == QNetworkReply::NoError) {
            QByteArray imageData = reply->readAll();    //转换成字节数组!
            QPixmap pixmap;
            if (pixmap.loadFromData(imageData)) {
                ui->label_albumPic->setPixmap(pixmap); // 设置到标签
            } else {
                qDebug() << "图片加载失败!";
            }
        } else {
            qDebug() << "请求失败:" << reply->errorString();
        }
        reply->deleteLater(); // 清理回复
    });
    ui->label_albumPic->setScaledContents(true); // 使内容自适应标签大小

    mvid=mvID_list[index];//获取当前选中歌曲的mvid值
    //判断是否有mvid
    if(mvid==0)
    {
        ui->pushButton_MV->hide();
    }
    else
    {
         ui->pushButton_MV->show();
    }
    //存储当前播放歌曲相关信息
    saveMusic("recently",current_index);//保存到最近播放列表中
}
//点击列表音乐播放槽
void MusicWindow::on_tableView_songs_clicked(const QModelIndex &index)
{
    qDebug()<<"index="<<index.row();
    qDebug()<<songsId_list[index.row()];
    qDebug()<<mvID_list[index.row()];
    qDebug()<<songName_list[index.row()];
    current_index=index.row();//记录当前索引号
    song_id=songsId_list[current_index];//记录当前歌曲ID号
    play_music(current_index);
}

//MV播放槽
void MusicWindow::on_pushButton_MV_clicked()
{
    //变成暂停按钮
    ui->pushButton_switch->setIcon(QIcon(":/img/PauseCircle.svg"));
    ui->pushButton_switch->setToolTip("暂停");
    isPlayMV=true;
    //停止音乐播放
    player->stop();
    mvPlayer=new VideoPlayer;
    //加载MV
    mvPlayer->Play_mv(mvid);
    mvPlayer->setWindowFlag(Qt::FramelessWindowHint,true);//去掉主窗口的边框
    mvPlayer->setWindowFlag(Qt::WindowStaysOnTopHint);
    mvPlayer->setMinimumSize(1071,591);
    mvPlayer->move(570,130);
    mvPlayer->show();
}



//音量变化槽
void MusicWindow::on_horizontalSlider_volume_sliderReleased()
{
    player->setVolume(ui->horizontalSlider_volume->value());
}

//上一首
void MusicWindow::on_pushButton_lastsong_clicked()
{
    //判断是不是第一首
    if(current_index==0)
    {
        QMessageBox::warning(this,"播放错误","当前歌曲是第一首!");
        return;
    }
    current_index=current_index-1;
    song_id=songsId_list[current_index];//更新当前歌曲ID

    //判断是否在显示歌词
    if(is_showLyric)
    {
        lyricsWindow->close();//关闭歌词窗体
    }

    //判断是否在播放MV
    if(isPlayMV)
    {
        mvPlayer->close();//关闭当前MV
        mvPlayer->Play_mv(mvID_list[current_index]);
    }
    else
        play_music(current_index);

}

//下一首
void MusicWindow::on_pushButton_nextsong_clicked()
{
    //判断是不是最后一首
    if(current_index==songsId_list.size()-1)
    {
        QMessageBox::warning(this,"播放错误","当前歌曲是最后一首!");
        return;
    }
    current_index=current_index+1;
    song_id=songsId_list[current_index];//更新当前歌曲ID

    //判断是否在显示歌词
    if(is_showLyric)
    {
        lyricsWindow->close();//关闭歌词窗体
    }

    if(isPlayMV)
    {
        mvPlayer->close();//关闭当前MV
        mvPlayer->Play_mv(mvID_list[current_index]);
    }
    else
        play_music(current_index);
}

//切换歌词显示槽
void MusicWindow::on_label_albumPic_linkActivated()
{
    //判断是否点击鼠标
    if(!is_showLyric)
    {
        lyricsWindow->show();
        ui->tableView_songs->hide();
//        qDebug()<<"song_id==="<<song_id;
        connect(player,&QMediaPlayer::positionChanged,lyricsWindow,&LyricsWindow::positionChanged);
//        ui->label_albumPic->setPixmap(QPixmap(":/img/BxCollapseAlt.svg"));
//        ui->label_albumPic->setScaledContents(false); // 不随标签大小变化
        lyricsWindow->show();
        is_showLyric=true;
    }
    else
    {
        ui->tableView_songs->show();
        lyricsWindow->hide();
        is_showLyric=false;
    }
}

//界面跳转
void MusicWindow::on_listWidget_menu_currentRowChanged(int currentRow)
{
    switch (currentRow)
    {
    //发现音乐界面
    case 0:
        //关闭歌词
        if(is_showLyric)
        {
            lyricsWindow->close();
            is_showLyric=false;
        }
        if (ui->tableView_songs->model()->columnCount() > 0)
        {
            ui->tableView_songs->setModel(nullptr);
        }
        ui->tableView_songs->show();
        break;
    //本地音乐界面
    case 1:
        //关闭歌词
        if(is_showLyric)
        {
            lyricsWindow->close();
            is_showLyric=false;
        }
        loadLocalFile();
        ui->tableView_songs->hide();
        break;
    //最近播放界面
    case 2:
        //关闭歌词
        if(is_showLyric)
        {
            lyricsWindow->close();
            is_showLyric=false;
        }
        //判断表中是否有数据
//        if (ui->tableView_songs->model()->columnCount() > 0)
//        {
//            ui->tableView_songs->model()->removeColumns(0,3);//清除表格数据
//        }
        set_playlist("recently");//设置播放列表为最近播放列表
        break;
    //我的收藏界面
    case 3:
        //关闭歌词
        if(is_showLyric)
        {
            lyricsWindow->close();
            is_showLyric=false;
        }
        set_playlist("myFavorite");//设置播放列表为我的收藏列表
        break;
    //我的歌单界面
    case 4:
        //关闭歌词
        if(is_showLyric)
        {
            lyricsWindow->close();
            is_showLyric=false;
        }
        qDebug()<<"你选择了我的歌单界面";
        break;
    }
}
